home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / openssl / crypto.h < prev    next >
C/C++ Source or Header  |  2006-04-25  |  20KB  |  519 lines
  1. /* crypto/crypto.h */
  2. /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  3.  * All rights reserved.
  4.  *
  5.  * This package is an SSL implementation written
  6.  * by Eric Young (eay@cryptsoft.com).
  7.  * The implementation was written so as to conform with Netscapes SSL.
  8.  * 
  9.  * This library is free for commercial and non-commercial use as long as
  10.  * the following conditions are aheared to.  The following conditions
  11.  * apply to all code found in this distribution, be it the RC4, RSA,
  12.  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13.  * included with this distribution is covered by the same copyright terms
  14.  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15.  * 
  16.  * Copyright remains Eric Young's, and as such any Copyright notices in
  17.  * the code are not to be removed.
  18.  * If this package is used in a product, Eric Young should be given attribution
  19.  * as the author of the parts of the library used.
  20.  * This can be in the form of a textual message at program startup or
  21.  * in documentation (online or textual) provided with the package.
  22.  * 
  23.  * Redistribution and use in source and binary forms, with or without
  24.  * modification, are permitted provided that the following conditions
  25.  * are met:
  26.  * 1. Redistributions of source code must retain the copyright
  27.  *    notice, this list of conditions and the following disclaimer.
  28.  * 2. Redistributions in binary form must reproduce the above copyright
  29.  *    notice, this list of conditions and the following disclaimer in the
  30.  *    documentation and/or other materials provided with the distribution.
  31.  * 3. All advertising materials mentioning features or use of this software
  32.  *    must display the following acknowledgement:
  33.  *    "This product includes cryptographic software written by
  34.  *     Eric Young (eay@cryptsoft.com)"
  35.  *    The word 'cryptographic' can be left out if the rouines from the library
  36.  *    being used are not cryptographic related :-).
  37.  * 4. If you include any Windows specific code (or a derivative thereof) from 
  38.  *    the apps directory (application code) you must include an acknowledgement:
  39.  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40.  * 
  41.  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51.  * SUCH DAMAGE.
  52.  * 
  53.  * The licence and distribution terms for any publically available version or
  54.  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55.  * copied and put under another distribution licence
  56.  * [including the GNU Public Licence.]
  57.  */
  58.  
  59. #ifndef HEADER_CRYPTO_H
  60. #define HEADER_CRYPTO_H
  61.  
  62. #include <stdlib.h>
  63.  
  64. #ifndef OPENSSL_NO_FP_API
  65. #include <stdio.h>
  66. #endif
  67.  
  68. #include <openssl/stack.h>
  69. #include <openssl/safestack.h>
  70. #include <openssl/opensslv.h>
  71.  
  72. #ifdef CHARSET_EBCDIC
  73. #include <openssl/ebcdic.h>
  74. #endif
  75.  
  76. /* Resolve problems on some operating systems with symbol names that clash
  77.    one way or another */
  78. #include <openssl/symhacks.h>
  79.  
  80. #ifdef  __cplusplus
  81. extern "C" {
  82. #endif
  83.  
  84. /* Backward compatibility to SSLeay */
  85. /* This is more to be used to check the correct DLL is being used
  86.  * in the MS world. */
  87. #define SSLEAY_VERSION_NUMBER    OPENSSL_VERSION_NUMBER
  88. #define SSLEAY_VERSION        0
  89. /* #define SSLEAY_OPTIONS    1 no longer supported */
  90. #define SSLEAY_CFLAGS        2
  91. #define SSLEAY_BUILT_ON        3
  92. #define SSLEAY_PLATFORM        4
  93. #define SSLEAY_DIR        5
  94.  
  95. /* When changing the CRYPTO_LOCK_* list, be sure to maintin the text lock
  96.  * names in cryptlib.c
  97.  */
  98.  
  99. #define CRYPTO_LOCK_ERR            1
  100. #define CRYPTO_LOCK_EX_DATA        2
  101. #define CRYPTO_LOCK_X509        3
  102. #define CRYPTO_LOCK_X509_INFO        4
  103. #define CRYPTO_LOCK_X509_PKEY        5
  104. #define CRYPTO_LOCK_X509_CRL        6
  105. #define CRYPTO_LOCK_X509_REQ        7
  106. #define CRYPTO_LOCK_DSA            8
  107. #define CRYPTO_LOCK_RSA            9
  108. #define CRYPTO_LOCK_EVP_PKEY        10
  109. #define CRYPTO_LOCK_X509_STORE        11
  110. #define CRYPTO_LOCK_SSL_CTX        12
  111. #define CRYPTO_LOCK_SSL_CERT        13
  112. #define CRYPTO_LOCK_SSL_SESSION        14
  113. #define CRYPTO_LOCK_SSL_SESS_CERT    15
  114. #define CRYPTO_LOCK_SSL            16
  115. #define CRYPTO_LOCK_SSL_METHOD        17
  116. #define CRYPTO_LOCK_RAND        18
  117. #define CRYPTO_LOCK_RAND2        19
  118. #define CRYPTO_LOCK_MALLOC        20
  119. #define CRYPTO_LOCK_BIO            21
  120. #define CRYPTO_LOCK_GETHOSTBYNAME    22
  121. #define CRYPTO_LOCK_GETSERVBYNAME    23
  122. #define CRYPTO_LOCK_READDIR        24
  123. #define CRYPTO_LOCK_RSA_BLINDING    25
  124. #define CRYPTO_LOCK_DH            26
  125. #define CRYPTO_LOCK_MALLOC2        27
  126. #define CRYPTO_LOCK_DSO            28
  127. #define CRYPTO_LOCK_DYNLOCK        29
  128. #define CRYPTO_LOCK_ENGINE        30
  129. #define CRYPTO_LOCK_UI            31
  130. #define CRYPTO_LOCK_HWCRHK        32 /* This is a HACK which will disappear in 0.9.8 */
  131. #define CRYPTO_LOCK_FIPS        33
  132. #define CRYPTO_LOCK_FIPS2        34
  133. #define CRYPTO_NUM_LOCKS        35
  134.  
  135. #define CRYPTO_LOCK        1
  136. #define CRYPTO_UNLOCK        2
  137. #define CRYPTO_READ        4
  138. #define CRYPTO_WRITE        8
  139.  
  140. #ifndef OPENSSL_NO_LOCKING
  141. #ifndef CRYPTO_w_lock
  142. #define CRYPTO_w_lock(type)    \
  143.     CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
  144. #define CRYPTO_w_unlock(type)    \
  145.     CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
  146. #define CRYPTO_r_lock(type)    \
  147.     CRYPTO_lock(CRYPTO_LOCK|CRYPTO_READ,type,__FILE__,__LINE__)
  148. #define CRYPTO_r_unlock(type)    \
  149.     CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_READ,type,__FILE__,__LINE__)
  150. #define CRYPTO_add(addr,amount,type)    \
  151.     CRYPTO_add_lock(addr,amount,type,__FILE__,__LINE__)
  152. #endif
  153. #else
  154. #define CRYPTO_w_lock(a)
  155. #define CRYPTO_w_unlock(a)
  156. #define CRYPTO_r_lock(a)
  157. #define CRYPTO_r_unlock(a)
  158. #define CRYPTO_add(a,b,c)    ((*(a))+=(b))
  159. #endif
  160.  
  161. /* Some applications as well as some parts of OpenSSL need to allocate
  162.    and deallocate locks in a dynamic fashion.  The following typedef
  163.    makes this possible in a type-safe manner.  */
  164. /* struct CRYPTO_dynlock_value has to be defined by the application. */
  165. typedef struct
  166.     {
  167.     int references;
  168.     struct CRYPTO_dynlock_value *data;
  169.     } CRYPTO_dynlock;
  170.  
  171.  
  172. /* The following can be used to detect memory leaks in the SSLeay library.
  173.  * It used, it turns on malloc checking */
  174.  
  175. #define CRYPTO_MEM_CHECK_OFF    0x0    /* an enume */
  176. #define CRYPTO_MEM_CHECK_ON    0x1    /* a bit */
  177. #define CRYPTO_MEM_CHECK_ENABLE    0x2    /* a bit */
  178. #define CRYPTO_MEM_CHECK_DISABLE 0x3    /* an enume */
  179.  
  180. /* The following are bit values to turn on or off options connected to the
  181.  * malloc checking functionality */
  182.  
  183. /* Adds time to the memory checking information */
  184. #define V_CRYPTO_MDEBUG_TIME    0x1 /* a bit */
  185. /* Adds thread number to the memory checking information */
  186. #define V_CRYPTO_MDEBUG_THREAD    0x2 /* a bit */
  187.  
  188. #define V_CRYPTO_MDEBUG_ALL (V_CRYPTO_MDEBUG_TIME | V_CRYPTO_MDEBUG_THREAD)
  189.  
  190.  
  191. /* predec of the BIO type */
  192. typedef struct bio_st BIO_dummy;
  193.  
  194. typedef struct crypto_ex_data_st
  195.     {
  196.     STACK *sk;
  197.     int dummy; /* gcc is screwing up this data structure :-( */
  198.     } CRYPTO_EX_DATA;
  199.  
  200. /* Called when a new object is created */
  201. typedef int CRYPTO_EX_new(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
  202.                     int idx, long argl, void *argp);
  203. /* Called when an object is free()ed */
  204. typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
  205.                     int idx, long argl, void *argp);
  206. /* Called when we need to dup an object */
  207. typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, void *from_d, 
  208.                     int idx, long argl, void *argp);
  209.  
  210. /* This stuff is basically class callback functions
  211.  * The current classes are SSL_CTX, SSL, SSL_SESSION, and a few more */
  212.  
  213. typedef struct crypto_ex_data_func_st
  214.     {
  215.     long argl;    /* Arbitary long */
  216.     void *argp;    /* Arbitary void * */
  217.     CRYPTO_EX_new *new_func;
  218.     CRYPTO_EX_free *free_func;
  219.     CRYPTO_EX_dup *dup_func;
  220.     } CRYPTO_EX_DATA_FUNCS;
  221.  
  222. DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS)
  223.  
  224. /* Per class, we have a STACK of CRYPTO_EX_DATA_FUNCS for each CRYPTO_EX_DATA
  225.  * entry.
  226.  */
  227.  
  228. #define CRYPTO_EX_INDEX_BIO        0
  229. #define CRYPTO_EX_INDEX_SSL        1
  230. #define CRYPTO_EX_INDEX_SSL_CTX        2
  231. #define CRYPTO_EX_INDEX_SSL_SESSION    3
  232. #define CRYPTO_EX_INDEX_X509_STORE    4
  233. #define CRYPTO_EX_INDEX_X509_STORE_CTX    5
  234. #define CRYPTO_EX_INDEX_RSA        6
  235. #define CRYPTO_EX_INDEX_DSA        7
  236. #define CRYPTO_EX_INDEX_DH        8
  237. #define CRYPTO_EX_INDEX_ENGINE        9
  238. #define CRYPTO_EX_INDEX_X509        10
  239. #define CRYPTO_EX_INDEX_UI        11
  240.  
  241. /* Dynamically assigned indexes start from this value (don't use directly, use
  242.  * via CRYPTO_ex_data_new_class). */
  243. #define CRYPTO_EX_INDEX_USER        100
  244.  
  245.  
  246. /* This is the default callbacks, but we can have others as well:
  247.  * this is needed in Win32 where the application malloc and the
  248.  * library malloc may not be the same.
  249.  */
  250. #define CRYPTO_malloc_init()    CRYPTO_set_mem_functions(\
  251.     malloc, realloc, free)
  252.  
  253. #if defined CRYPTO_MDEBUG_ALL || defined CRYPTO_MDEBUG_TIME || defined CRYPTO_MDEBUG_THREAD
  254. # ifndef CRYPTO_MDEBUG /* avoid duplicate #define */
  255. #  define CRYPTO_MDEBUG
  256. # endif
  257. #endif
  258.  
  259. /* Set standard debugging functions (not done by default
  260.  * unless CRYPTO_MDEBUG is defined) */
  261. #define CRYPTO_malloc_debug_init()    do {\
  262.     CRYPTO_set_mem_debug_functions(\
  263.         CRYPTO_dbg_malloc,\
  264.         CRYPTO_dbg_realloc,\
  265.         CRYPTO_dbg_free,\
  266.         CRYPTO_dbg_set_options,\
  267.         CRYPTO_dbg_get_options);\
  268.     } while(0)
  269.  
  270. int CRYPTO_mem_ctrl(int mode);
  271. int CRYPTO_is_mem_check_on(void);
  272.  
  273. /* for applications */
  274. #define MemCheck_start() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON)
  275. #define MemCheck_stop()    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF)
  276.  
  277. /* for library-internal use */
  278. #define MemCheck_on()    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE)
  279. #define MemCheck_off()    CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE)
  280. #define is_MemCheck_on() CRYPTO_is_mem_check_on()
  281.  
  282. #define OPENSSL_malloc(num)    CRYPTO_malloc((int)num,__FILE__,__LINE__)
  283. #define OPENSSL_realloc(addr,num) \
  284.     CRYPTO_realloc((char *)addr,(int)num,__FILE__,__LINE__)
  285. #define OPENSSL_realloc_clean(addr,old_num,num) \
  286.     CRYPTO_realloc_clean(addr,old_num,num,__FILE__,__LINE__)
  287. #define OPENSSL_remalloc(addr,num) \
  288.     CRYPTO_remalloc((char **)addr,(int)num,__FILE__,__LINE__)
  289. #define OPENSSL_freeFunc    CRYPTO_free
  290. #define OPENSSL_free(addr)    CRYPTO_free(addr)
  291.  
  292. #define OPENSSL_malloc_locked(num) \
  293.     CRYPTO_malloc_locked((int)num,__FILE__,__LINE__)
  294. #define OPENSSL_free_locked(addr) CRYPTO_free_locked(addr)
  295.  
  296.  
  297. const char *SSLeay_version(int type);
  298. unsigned long SSLeay(void);
  299.  
  300. int OPENSSL_issetugid(void);
  301.  
  302. /* An opaque type representing an implementation of "ex_data" support */
  303. typedef struct st_CRYPTO_EX_DATA_IMPL    CRYPTO_EX_DATA_IMPL;
  304. /* Return an opaque pointer to the current "ex_data" implementation */
  305. const CRYPTO_EX_DATA_IMPL *CRYPTO_get_ex_data_implementation(void);
  306. /* Sets the "ex_data" implementation to be used (if it's not too late) */
  307. int CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i);
  308. /* Get a new "ex_data" class, and return the corresponding "class_index" */
  309. int CRYPTO_ex_data_new_class(void);
  310. /* Within a given class, get/register a new index */
  311. int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
  312.         CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
  313.         CRYPTO_EX_free *free_func);
  314. /* Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a given
  315.  * class (invokes whatever per-class callbacks are applicable) */
  316. int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
  317. int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
  318.         CRYPTO_EX_DATA *from);
  319. void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
  320. /* Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular index
  321.  * (relative to the class type involved) */
  322. int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
  323. void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad,int idx);
  324. /* This function cleans up all "ex_data" state. It mustn't be called under
  325.  * potential race-conditions. */
  326. void CRYPTO_cleanup_all_ex_data(void);
  327.  
  328. int CRYPTO_get_new_lockid(char *name);
  329.  
  330. int CRYPTO_num_locks(void); /* return CRYPTO_NUM_LOCKS (shared libs!) */
  331. void CRYPTO_lock(int mode, int type,const char *file,int line);
  332. void CRYPTO_set_locking_callback(void (*func)(int mode,int type,
  333.                           const char *file,int line));
  334. void (*CRYPTO_get_locking_callback(void))(int mode,int type,const char *file,
  335.         int line);
  336. void CRYPTO_set_add_lock_callback(int (*func)(int *num,int mount,int type,
  337.                           const char *file, int line));
  338. int (*CRYPTO_get_add_lock_callback(void))(int *num,int mount,int type,
  339.                       const char *file,int line);
  340. void CRYPTO_set_id_callback(unsigned long (*func)(void));
  341. unsigned long (*CRYPTO_get_id_callback(void))(void);
  342. unsigned long CRYPTO_thread_id(void);
  343. const char *CRYPTO_get_lock_name(int type);
  344. int CRYPTO_add_lock(int *pointer,int amount,int type, const char *file,
  345.             int line);
  346.  
  347. int CRYPTO_get_new_dynlockid(void);
  348. void CRYPTO_destroy_dynlockid(int i);
  349. struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i);
  350. void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*dyn_create_function)(const char *file, int line));
  351. void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)(int mode, struct CRYPTO_dynlock_value *l, const char *file, int line));
  352. void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function)(struct CRYPTO_dynlock_value *l, const char *file, int line));
  353. struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))(const char *file,int line);
  354. void (*CRYPTO_get_dynlock_lock_callback(void))(int mode, struct CRYPTO_dynlock_value *l, const char *file,int line);
  355. void (*CRYPTO_get_dynlock_destroy_callback(void))(struct CRYPTO_dynlock_value *l, const char *file,int line);
  356.  
  357. /* CRYPTO_set_mem_functions includes CRYPTO_set_locked_mem_functions --
  358.  * call the latter last if you need different functions */
  359. int CRYPTO_set_mem_functions(void *(*m)(size_t),void *(*r)(void *,size_t), void (*f)(void *));
  360. int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*free_func)(void *));
  361. int CRYPTO_set_mem_ex_functions(void *(*m)(size_t,const char *,int),
  362.                                 void *(*r)(void *,size_t,const char *,int),
  363.                                 void (*f)(void *));
  364. int CRYPTO_set_locked_mem_ex_functions(void *(*m)(size_t,const char *,int),
  365.                                        void (*free_func)(void *));
  366. int CRYPTO_set_mem_debug_functions(void (*m)(void *,int,const char *,int,int),
  367.                    void (*r)(void *,void *,int,const char *,int,int),
  368.                    void (*f)(void *,int),
  369.                    void (*so)(long),
  370.                    long (*go)(void));
  371. void CRYPTO_get_mem_functions(void *(**m)(size_t),void *(**r)(void *, size_t), void (**f)(void *));
  372. void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *));
  373. void CRYPTO_get_mem_ex_functions(void *(**m)(size_t,const char *,int),
  374.                                  void *(**r)(void *, size_t,const char *,int),
  375.                                  void (**f)(void *));
  376. void CRYPTO_get_locked_mem_ex_functions(void *(**m)(size_t,const char *,int),
  377.                                         void (**f)(void *));
  378. void CRYPTO_get_mem_debug_functions(void (**m)(void *,int,const char *,int,int),
  379.                     void (**r)(void *,void *,int,const char *,int,int),
  380.                     void (**f)(void *,int),
  381.                     void (**so)(long),
  382.                     long (**go)(void));
  383.  
  384. void *CRYPTO_malloc_locked(int num, const char *file, int line);
  385. void CRYPTO_free_locked(void *);
  386. void *CRYPTO_malloc(int num, const char *file, int line);
  387. void CRYPTO_free(void *);
  388. void *CRYPTO_realloc(void *addr,int num, const char *file, int line);
  389. void *CRYPTO_realloc_clean(void *addr,int old_num,int num,const char *file,
  390.                int line);
  391. void *CRYPTO_remalloc(void *addr,int num, const char *file, int line);
  392.  
  393. void OPENSSL_cleanse(void *ptr, size_t len);
  394.  
  395. void CRYPTO_set_mem_debug_options(long bits);
  396. long CRYPTO_get_mem_debug_options(void);
  397.  
  398. #define CRYPTO_push_info(info) \
  399.         CRYPTO_push_info_(info, __FILE__, __LINE__);
  400. int CRYPTO_push_info_(const char *info, const char *file, int line);
  401. int CRYPTO_pop_info(void);
  402. int CRYPTO_remove_all_info(void);
  403.  
  404.  
  405. /* Default debugging functions (enabled by CRYPTO_malloc_debug_init() macro;
  406.  * used as default in CRYPTO_MDEBUG compilations): */
  407. /* The last argument has the following significance:
  408.  *
  409.  * 0:    called before the actual memory allocation has taken place
  410.  * 1:    called after the actual memory allocation has taken place
  411.  */
  412. void CRYPTO_dbg_malloc(void *addr,int num,const char *file,int line,int before_p);
  413. void CRYPTO_dbg_realloc(void *addr1,void *addr2,int num,const char *file,int line,int before_p);
  414. void CRYPTO_dbg_free(void *addr,int before_p);
  415. /* Tell the debugging code about options.  By default, the following values
  416.  * apply:
  417.  *
  418.  * 0:                           Clear all options.
  419.  * V_CRYPTO_MDEBUG_TIME (1):    Set the "Show Time" option.
  420.  * V_CRYPTO_MDEBUG_THREAD (2):  Set the "Show Thread Number" option.
  421.  * V_CRYPTO_MDEBUG_ALL (3):     1 + 2
  422.  */
  423. void CRYPTO_dbg_set_options(long bits);
  424. long CRYPTO_dbg_get_options(void);
  425.  
  426.  
  427. #ifndef OPENSSL_NO_FP_API
  428. void CRYPTO_mem_leaks_fp(FILE *);
  429. #endif
  430. void CRYPTO_mem_leaks(struct bio_st *bio);
  431. /* unsigned long order, char *file, int line, int num_bytes, char *addr */
  432. typedef void *CRYPTO_MEM_LEAK_CB(unsigned long, const char *, int, int, void *);
  433. void CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb);
  434.  
  435. /* die if we have to */
  436. void OpenSSLDie(const char *file,int line,const char *assertion);
  437. #define OPENSSL_assert(e)    (void)((e) ? 0 : (OpenSSLDie(__FILE__, __LINE__, #e),1))
  438.  
  439. #ifdef OPENSSL_FIPS
  440. #define FIPS_ERROR_IGNORED(alg) OpenSSLDie(__FILE__, __LINE__, \
  441.         alg " previous FIPS forbidden algorithm error ignored");
  442.  
  443. #define FIPS_BAD_ABORT(alg) OpenSSLDie(__FILE__, __LINE__, \
  444.         #alg " Algorithm forbidden in FIPS mode");
  445.  
  446. #ifdef OPENSSL_FIPS_STRICT
  447. #define FIPS_BAD_ALGORITHM(alg) FIPS_BAD_ABORT(alg)
  448. #else
  449. #define FIPS_BAD_ALGORITHM(alg) \
  450.     { \
  451.     FIPSerr(FIPS_F_HASH_FINAL,FIPS_R_NON_FIPS_METHOD); \
  452.     ERR_add_error_data(2, "Algorithm=", #alg); \
  453.     return 0; \
  454.     }
  455. #endif
  456.  
  457. /* Low level digest API blocking macro */
  458.  
  459. #define FIPS_NON_FIPS_MD_Init(alg) \
  460.     int alg##_Init(alg##_CTX *c) \
  461.         { \
  462.         if (FIPS_mode()) \
  463.             FIPS_BAD_ALGORITHM(alg) \
  464.         return private_##alg##_Init(c); \
  465.         } \
  466.     int private_##alg##_Init(alg##_CTX *c)
  467.  
  468. /* For ciphers the API often varies from cipher to cipher and each needs to
  469.  * be treated as a special case. Variable key length ciphers (Blowfish, RC4,
  470.  * CAST) however are very similar and can use a blocking macro.
  471.  */
  472.  
  473. #define FIPS_NON_FIPS_VCIPHER_Init(alg) \
  474.     void alg##_set_key(alg##_KEY *key, int len, const unsigned char *data) \
  475.         { \
  476.         if (FIPS_mode()) \
  477.             FIPS_BAD_ABORT(alg) \
  478.         private_##alg##_set_key(key, len, data); \
  479.         } \
  480.     void private_##alg##_set_key(alg##_KEY *key, int len, \
  481.                     const unsigned char *data)
  482.  
  483. #else
  484.  
  485. #define FIPS_NON_FIPS_VCIPHER_Init(alg) \
  486.     void alg##_set_key(alg##_KEY *key, int len, const unsigned char *data)
  487.  
  488. #define FIPS_NON_FIPS_MD_Init(alg) \
  489.     int alg##_Init(alg##_CTX *c) 
  490.  
  491. #endif /* def OPENSSL_FIPS */
  492.  
  493. /* BEGIN ERROR CODES */
  494. /* The following lines are auto generated by the script mkerr.pl. Any changes
  495.  * made after this point may be overwritten when the script is next run.
  496.  */
  497. void ERR_load_CRYPTO_strings(void);
  498.  
  499. /* Error codes for the CRYPTO functions. */
  500.  
  501. /* Function codes. */
  502. #define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX         100
  503. #define CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID         103
  504. #define CRYPTO_F_CRYPTO_GET_NEW_LOCKID             101
  505. #define CRYPTO_F_CRYPTO_SET_EX_DATA             102
  506. #define CRYPTO_F_DEF_ADD_INDEX                 104
  507. #define CRYPTO_F_DEF_GET_CLASS                 105
  508. #define CRYPTO_F_INT_DUP_EX_DATA             106
  509. #define CRYPTO_F_INT_FREE_EX_DATA             107
  510. #define CRYPTO_F_INT_NEW_EX_DATA             108
  511.  
  512. /* Reason codes. */
  513. #define CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK         100
  514.  
  515. #ifdef  __cplusplus
  516. }
  517. #endif
  518. #endif
  519.